home *** CD-ROM | disk | FTP | other *** search
/ Software Vault: The Gold Collection / Software Vault - The Gold Collection (American Databankers) (1993).ISO / cdr47 / 335_04.zip / FRASMAIN.C < prev    next >
C/C++ Source or Header  |  1993-04-13  |  8KB  |  413 lines
  1. /*
  2. HEADER:     ;
  3. TITLE:         Frankenstein Cross Assemblers;
  4. VERSION:     2.0;
  5. DESCRIPTION: "    Reconfigurable Cross-assembler producing Intel (TM)
  6.         Hex format object records.  ";
  7. KEYWORDS:     cross-assemblers, 1805, 2650, 6301, 6502, 6805, 6809, 
  8.         6811, tms7000, 8048, 8051, 8096, z8, z80;
  9. SYSTEM:     UNIX, MS-Dos ;
  10. FILENAME:     frasmain.c;
  11. WARNINGS:     "This software is in the public domain.  
  12.         Any prior copyright claims are relinquished.  
  13.  
  14.         This software is distributed with no warranty whatever.  
  15.         The author takes no responsibility for the consequences 
  16.         of its use.
  17.  
  18.         Yacc (or Bison) required to compile."  ;
  19. SEE-ALSO:     base.doc, as*.doc (machine specific appendices) , 
  20.         as*.1 (man pages);
  21. AUTHORS:     Mark Zenier;
  22. COMPILERS:     Microport Sys V/AT, ATT Yacc, Turbo C V1.5, Bison (CUG disk 285)
  23.         (previous versions Xenix, Unisoft 68000 Version 7, Sun 3);
  24. */
  25. /*
  26.     description    Main file
  27.     usage        Unix, framework crossassembler
  28.     history        September 25, 1987
  29.             August 3, 1988    v 1.4
  30.             September 14, 1990  v 1.5  Dosified
  31. */
  32.  
  33. #define    Global
  34.  
  35. #include <stdio.h>
  36. #include "frasmdat.h"
  37.  
  38. FILE * intermedf = (FILE *) NULL;
  39. char *interfn = 
  40. #ifdef DOSTMP
  41.  "frtXXXXXX";
  42. #else
  43.  "/usr/tmp/frtXXXXXX";
  44. #endif
  45. char *hexfn, *loutfn;
  46. int errorcnt = 0, warncnt = 0;
  47. int listflag = FALSE, hexflag = FALSE, hexvalid = FALSE;
  48. static int debugmode = FALSE;
  49. static FILE *symbf;
  50. static char *symbfn;
  51. static int  symbflag = FALSE;
  52. char hexcva[17] = "0123456789abcdef";
  53.  
  54. #ifdef NOGETOPT
  55. #include "getopt.h"
  56. #endif
  57. main(argc, argv)
  58.     int argc;
  59.     char *(argv[]);
  60. /*
  61.     description    top driver routine for framework cross assembler
  62.                 set the cpu type if implemented in parser
  63.                 process the command line parameters
  64.                 setup the tables
  65.                 call the first pass parser
  66.                 print the symbol table
  67.                 call the second pass
  68.                 close down and delete the outputs if any errors
  69.     return        exit(2) for error, exit(0) for OK
  70. */
  71. {
  72.     extern char *optarg;
  73.     extern int optind;
  74.     int grv;
  75.  
  76.     grv = cpumatch(argv[0]);
  77.  
  78.     while( (grv = getopt(argc, argv, "dh:o:l:s:p:")) != EOF)
  79.     {
  80.         switch(grv)
  81.         {
  82.         case 'o':
  83.         case 'h':
  84.             hexfn = optarg;
  85.             hexflag = hexvalid = TRUE;
  86.             break;
  87.         
  88.         case 'l':
  89.             loutfn = optarg;
  90.             listflag = TRUE;
  91.             break;
  92.  
  93.         case 'd':
  94.             debugmode = TRUE;
  95.             break;
  96.  
  97.         case 's':
  98.             symbflag = TRUE;
  99.             symbfn = optarg;
  100.             break;
  101.  
  102.         case 'p':
  103.             if( ! cpumatch(optarg) )
  104.             {
  105.                 fprintf(stderr, 
  106.         "%s: no match on CPU type %s, default used\n", 
  107.                     argv[0], optarg);
  108.             }
  109.             break;
  110.  
  111.         case '?':
  112.             break;
  113.         }
  114.     }
  115.  
  116.     if(optind < argc)
  117.     {
  118.         if(strcmp(argv[optind], "-") == 0)
  119.         {
  120.             yyin = stdin;
  121.         }
  122.         else
  123.         {
  124.             if( (yyin = fopen(argv[optind], "r")) == (FILE *)NULL)
  125.             {
  126.                 fprintf(stderr, 
  127.                     "%s: cannot open input file %s\n",
  128.                     argv[0], argv[optind]);
  129.                 exit(1);
  130.             }
  131.         }
  132.     }
  133.     else
  134.     {
  135.         fprintf(stderr, "%s: no input file\n", argv[0]);
  136.         exit(1);
  137.     }
  138.  
  139.     if(listflag)
  140.     {
  141.         if(strcmp(argv[optind], loutfn) == 0) 
  142.         {
  143.             fprintf(stderr, "%s: list file overwrites input %s\n",
  144.                 argv[0], loutfn);
  145.             listflag = FALSE;
  146.         }
  147.         else if( (loutf = fopen(loutfn, "w")) == (FILE *) NULL)
  148.         {
  149.             fprintf(stderr, "%s: cannot open list file %s\n",
  150.                 argv[0], loutfn);
  151.             listflag = FALSE;
  152.         }
  153.     }
  154.  
  155.     if( ! listflag)
  156.     {
  157.         loutf = stdout;
  158.     }
  159.  
  160.     mktemp(interfn);
  161.     if( (intermedf = fopen(interfn, "w")) == (FILE *) NULL)
  162.     {
  163.         fprintf(stderr, "%s: cannot open temp file %s\n",
  164.             argv[0], interfn);
  165.         exit(1);
  166.     }
  167.  
  168.     setophash();
  169.     setreserved();
  170.     elseifstk[0] = endifstk[0] = If_Err;
  171.     fprintf(intermedf, "F:%s\n", argv[optind]);
  172.     infilestk[0].fpt = yyin;
  173.     infilestk[0].fnm = argv[optind];
  174.     currfstk = 0;
  175.     currseg = 0;
  176.     
  177.     yyparse();
  178.     
  179.     if(ifstkpt != 0)
  180.         fraerror("active IF at end of file");
  181.  
  182.     buildsymbolindex();
  183.     if(listflag)
  184.         printsymbols();
  185.  
  186.     if(symbflag)
  187.     {
  188.         if(strcmp(argv[optind], symbfn) == 0) 
  189.         {
  190.             fprintf(stderr, "%s: symbol file overwrites input %s\n",
  191.                 argv[0], symbfn);
  192.         }
  193.         else if( (symbf = fopen(symbfn, "w")) == (FILE *) NULL)
  194.         {
  195.             fprintf(stderr, "%s: cannot open symbol file %s\n",
  196.                 argv[0], symbfn);
  197.         }
  198.         else
  199.         {
  200.             filesymbols();
  201.             fclose(symbf);
  202.         }
  203.     }
  204.  
  205.     
  206.     fclose(intermedf);
  207.     if( (intermedf = fopen(interfn, "r")) == (FILE *) NULL)
  208.     {
  209.         fprintf(stderr, "%s: cannot open temp file %s\n",
  210.             argv[0], interfn);
  211.         exit(1);
  212.     }
  213.  
  214.     if(errorcnt > 0)
  215.         hexflag = FALSE;
  216.  
  217.     if(hexflag)
  218.     {
  219.         if(strcmp(argv[optind], hexfn) == 0) 
  220.         {
  221.             fprintf(stderr, "%s: hex output overwrites input %s\n",
  222.                 argv[0], hexfn);
  223.             hexflag = FALSE;
  224.         }
  225.         else if( (hexoutf = fopen(hexfn, "w")) == (FILE *) NULL)
  226.         {
  227.             fprintf(stderr, "%s: cannot open hex output %s\n",
  228.                 argv[0], hexfn);
  229.             hexflag = FALSE;
  230.         }
  231.     }
  232.  
  233.     currfstk = 0;
  234.     outphase();
  235.  
  236.     if(errorcnt > 0)
  237.         hexvalid = FALSE;
  238.  
  239.     fprintf(loutf, " ERROR SUMMARY - ERRORS DETECTED %d\n", errorcnt);
  240.     fprintf(loutf, "               -  WARNINGS       %d\n", warncnt);
  241.  
  242.     if(listflag)
  243.     {
  244.         fprintf(stderr, " ERROR SUMMARY - ERRORS DETECTED %d\n", 
  245.             errorcnt);
  246.         fprintf(stderr, "               -  WARNINGS       %d\n", 
  247.             warncnt);
  248.     }
  249.  
  250.     if(listflag)
  251.         fclose(loutf);
  252.     
  253.     if(hexflag)
  254.     {
  255.         fclose(hexoutf);
  256.         if( ! hexvalid)
  257.             unlink(hexfn);
  258.     }
  259.     
  260.     fclose(intermedf);
  261.     if( ! debugmode)
  262.         unlink(interfn);
  263.     else
  264.         abort();
  265.     
  266.     exit(errorcnt > 0 ? 2 : 0);
  267. }
  268.         
  269.  
  270. frafatal(str)
  271.     char * str;
  272. /*
  273.     description    Fatal error subroutine, shutdown and quit right now!
  274.     parameters    message
  275.     globals        if debug mode is true, save intermediate file
  276.     return        exit(2)
  277. */
  278. {
  279.     fprintf(stderr, "Fatal error - %s\n",str);
  280.  
  281.     if( intermedf != (FILE *) NULL)
  282.     {
  283.         fclose(intermedf);
  284.         if( ! debugmode)
  285.             unlink(interfn);
  286.     }
  287.         
  288.     exit(2);
  289. }
  290.  
  291. frawarn(str)
  292.     char * str;
  293. /*
  294.     description    first pass - generate warning message by writing line
  295.             to intermediate file
  296.     parameters    message
  297.     globals        the count of warnings
  298. */
  299. {
  300.     fprintf(intermedf, "E: WARNING - %s\n",str);
  301.     warncnt++;
  302. }
  303.  
  304. fraerror(str)
  305.     char * str;
  306. /*
  307.     description    first pass - generate error message by writing line to
  308.             intermediate file
  309.     parameters    message
  310.     globals        count of errors
  311. */
  312. {
  313.     fprintf(intermedf, "E: ERROR - %s\n",str);
  314.     errorcnt++;
  315. }
  316.  
  317. fracherror(str, start, beyond)
  318.     char * str, *start, *beyond;
  319. /*
  320.     description    first pass - generate error message by writing line to
  321.             intermediate file
  322.     parameters    message
  323.             pointer to bad character definition
  324.             pointer after bad definition
  325.     globals        count of errors
  326. */
  327. {
  328.     char bcbuff[8];
  329.     int cnt;
  330.  
  331.     for(cnt=0; start < beyond && *start != '\0' && cnt < 7; cnt++)
  332.     {
  333.         bcbuff[cnt] = *start++;
  334.     }
  335.     bcbuff[cnt] = '\0';
  336.  
  337.     fprintf(intermedf, "E: ERROR - %s \'%s\'\n",str, bcbuff);
  338.     errorcnt++;
  339. }
  340.  
  341.  
  342. prtequvalue(fstr, lv)
  343.     char * fstr;
  344.     long lv;
  345. /*
  346.     description    first pass - generate comment lines in intermediate file
  347.             for the value in a set, equate, or org statement, etc...
  348.     parameters    format string and a long integer value
  349. */
  350. {
  351.     fprintf(intermedf, fstr, lv);
  352. }
  353.  
  354. #define SYMPERLINE 3
  355.  
  356. printsymbols()
  357. /*
  358.     description    print the symbols on the listing file, 3 symbols
  359.             across.  Only the first 15 characters are printed
  360.             though all are significant.  Reserved symbols are
  361.             not assigned symbol numbers and thus are not printed.
  362.     globals        the symbol index array and the symbol table elements.
  363. */
  364. {
  365.     int syn, npl = 0;
  366.     struct symel *syp;
  367.  
  368.     for(syn = 1; syn <nextsymnum; syn++)
  369.     {
  370.         if(npl >= SYMPERLINE)
  371.         {
  372.             fputc('\n', loutf);
  373.             npl = 0;
  374.         }
  375.  
  376.         syp = symbindex[syn];
  377.  
  378.         if(syp -> seg != SSG_UNDEF)
  379.             fprintf(loutf, "%8.8lx %-15.15s  ",syp -> value,
  380.                 syp -> symstr);
  381.         else
  382.             fprintf(loutf, "???????? %-15.15s  ", syp -> symstr);
  383.         npl++;
  384.     }
  385.  
  386.     if(npl > 0)
  387.         fputc('\n', loutf);
  388.  
  389.     fputc('\f', loutf);
  390. }
  391.  
  392.  
  393. filesymbols()
  394. /*
  395.     description    print the symbols to the symbol table file
  396.     globals        the symbol index array and the symbol table elements.
  397. */
  398. {
  399.     int syn;
  400.     struct symel *syp;
  401.  
  402.     for(syn = 1; syn <nextsymnum; syn++)
  403.     {
  404.         syp = symbindex[syn];
  405.  
  406.         if(syp -> seg != SSG_UNDEF)
  407.             fprintf(symbf, "%8.8lx %s\n",syp -> value,
  408.                 syp -> symstr);
  409.         else
  410.             fprintf(symbf, "???????? %s\n", syp -> symstr);
  411.     }
  412. }
  413.